/**
 * 数据可视化仪表盘模块
 * 负责初始化和管理所有图表组件
 */
const Dashboard = (function() {
    /* ========== 工具函数 ========== */
    const utils = {
        $: q => document.querySelector(q),
        $$: q => document.querySelectorAll(q),
        random: (min, max) => Math.floor(Math.random() * (max - min + 1)) + min,
        randomFloat: (min, max, decimals = 1) => parseFloat((Math.random() * (max - min) + min).toFixed(decimals)),
        
        
        /**
         * 安全地更新图表配置
         */
        safeSetOption: function(chart, option, chartName) {
            if (!chart || !chart.setOption || typeof chart.setOption !== 'function' || chart.isDisposed()) {
                console.warn(`${chartName} 图表实例无效，无法更新配置`);
                return false;
            }
            
            requestAnimationFrame(() => {
                try {
                    chart.setOption(option);
                    if (window.DEBUG) console.log(`${chartName} 更新成功`);
                    return true;
                } catch (e) {
                    console.error(`${chartName} 更新失败:`, e);
                    return false;
                }
            });
            return true;
        },
        
        /**
         * 清除定时器
         */
        clearTimer: function(timerId) {
            if (timerId) {
                clearInterval(timerId);
                return null;
            }
            return timerId;
        },
        
        /**
         * 生成随机日期数组
         */
        generateDateArray: function(days = 30) {
            const dates = [];
            const now = new Date();
            
            for (let i = days - 1; i >= 0; i--) {
                const date = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
                dates.push(`${date.getMonth() + 1}/${date.getDate()}`);
            }
            
            return dates;
        }
    };
    
    /* ========== 数据模型 ========== */
    const dataModel = {
        // 重置缓存以确保数据正确加载
        _init: function() {
            this.resetData();
        },
        // 国家列表
        countryNames: ['中国', '美国', '日本', '英国', '法国', '德国', '加拿大', '澳大利亚', '俄罗斯', '印度'],
        
        // 省份列表
        provinceNames: ['广东', '北京', '上海', '江苏', '浙江', '山东', '四川', '湖北', '河南', '福建'],
        
        // 年龄组列表
        ageGroups: ['0-18', '19-24', '25-34', '35-44', '45-54', '55+'],
        
        // 指标配置
        indicators: [
            { id: 'total-visitors', range: [1000000, 2000000] },
            { id: 'active-users', range: [50000, 100000] },
            { id: 'avg-time', range: [30, 120] },
            { id: 'bounce-rate', range: [20, 50] },
            { id: 'conversion-rate', range: [1, 5] },
            { id: 'daily-growth', range: 0.5, isPercent: true },
            { id: 'weekly-growth', range: 3, isPercent: true },
            { id: 'monthly-growth', range: 15, isPercent: true }
        ],
        
        // 共享的国家数据 - 确保地图和柱状图数据一致
        getCountryData: function() {
            // 生成一次数据并缓存，确保所有图表使用相同数据
            if (!this._countryData) {
                // 使用英文名称确保与世界地图匹配，同时保持中文显示
                // 为统计国家添加isCore标记，用于tooltip显示控制
                this._countryData = [
                    { name: 'China', value: 65454, isCore: true },
                    { name: 'United States', value: utils.random(40000, 90000), isCore: true },
                    { name: 'Japan', value: utils.random(30000, 80000), isCore: true },
                    { name: 'United Kingdom', value: utils.random(20000, 60000), isCore: true },
                    { name: 'France', value: utils.random(40000, 90000), isCore: true },
                    { name: 'Germany', value: utils.random(50000, 80000), isCore: true },
                    { name: 'Canada', value: utils.random(30000, 70000), isCore: true },
                    { name: 'Australia', value: utils.random(20000, 60000), isCore: true },
                    { name: 'Russia', value: utils.random(40000, 70000), isCore: true },
                    { name: 'India', value: utils.random(30000, 60000), isCore: true }
                ];
            }
            return this._countryData;
        },
        
        // 共享的省份数据
        getProvinceData: function() {
            // 生成一次数据并缓存，确保所有图表使用相同数据
            if (!this._provinceData) {
                // 省份名称映射 - 确保与ECharts中国地图的省份名称匹配
                const provinceNameMap = {
                    '广东': '广东省',
                    '北京': '北京市',
                    '上海': '上海市',
                    '江苏': '江苏省',
                    '浙江': '浙江省',
                    '山东': '山东省',
                    '四川': '四川省',
                    '湖北': '湖北省',
                    '河南': '河南省',
                    '福建': '福建省'
                };
                
                // 核心省份数据（将用于统计图表）
                const coreProvinces = this.provinceNames.map(name => ({
                    name: provinceNameMap[name] || name,
                    value: name === '河南' ? 155284 : utils.random(5000, 200000), // 河南固定为155284
                    isCore: true // 标记为核心省份，用于统计图表筛选
                }));
                
                // 其他省份数据（仅用于地图显示，不参与统计）
                const otherProvinces = [
                    { name: '河北省', value: utils.random(10000, 80000), isCore: false },
                    { name: '山西省', value: utils.random(5000, 60000), isCore: false },
                    { name: '内蒙古自治区', value: utils.random(3000, 50000), isCore: false },
                    { name: '辽宁省', value: utils.random(8000, 70000), isCore: false },
                    { name: '吉林省', value: utils.random(4000, 50000), isCore: false },
                    { name: '黑龙江省', value: utils.random(6000, 60000), isCore: false },
                    { name: '安徽省', value: utils.random(10000, 80000), isCore: false },
                    { name: '江西省', value: utils.random(8000, 70000), isCore: false },
                    { name: '湖南省', value: utils.random(9000, 75000), isCore: false },
                    { name: '广西壮族自治区', value: utils.random(7000, 65000), isCore: false },
                    { name: '海南省', value: utils.random(2000, 40000), isCore: false },
                    { name: '重庆市', value: utils.random(12000, 90000), isCore: false },
                    { name: '贵州省', value: utils.random(5000, 55000), isCore: false },
                    { name: '云南省', value: utils.random(6000, 60000), isCore: false },
                    { name: '西藏自治区', value: utils.random(1000, 20000), isCore: false },
                    { name: '陕西省', value: utils.random(9000, 75000), isCore: false },
                    { name: '甘肃省', value: utils.random(4000, 50000), isCore: false },
                    { name: '青海省', value: utils.random(2000, 30000), isCore: false },
                    { name: '宁夏回族自治区', value: utils.random(3000, 40000), isCore: false },
                    { name: '新疆维吾尔自治区', value: utils.random(5000, 55000), isCore: false },
                    { name: '台湾省', value: utils.random(8000, 70000), isCore: false },
                    { name: '香港特别行政区', value: utils.random(15000, 100000), isCore: false },
                    { name: '澳门特别行政区', value: utils.random(5000, 50000), isCore: false }
                ];
                
                // 合并所有省份数据
                this._provinceData = [...coreProvinces, ...otherProvinces];
            }
            return this._provinceData;
        },
        
        // 重置缓存数据（用于刷新）
        resetData: function() {
            this._countryData = null;
            this._provinceData = null;
        }
    };
    
    // 初始化数据模型
    dataModel._init();
    
    /* ========== 数据模型结束 ========== */
    
    /* ========== 图表控制器 ========== */
    const ChartController = {
        // 图表实例
        charts: {
            countryChart: null,     // 国家访问量柱状图
            provinceChart: null,    // 省份分布饼图
            ageChart: null,         // 年龄分布图表
            trendChart: null,       // 趋势折线图
            worldMap: null,         // 世界地图
            chinaMap: null          // 中国地图
        },
        
        // 定时器引用
        timers: {},
        
        /**
         * 初始化所有图表
         */
        init: function() {
            console.log('开始初始化图表...');
            
            try {
                // 先检查ECharts是否可用
                if (typeof echarts === 'undefined') {
                    console.error('ECharts库未加载');
                    return;
                }
                
                console.log('ECharts库已加载，开始初始化图表');
                
                // 初始化所有图表，包括地图
                this.initCountryChart();
                this.initProvinceChart();
                this.initAgeChart();
                this.initTrendChart();
                this.initWorldMap();
                this.initChinaMap();
                
                this.setupEventListeners();
                console.log('所有图表初始化完成');
            } catch (e) {
                console.error('图表初始化过程中发生错误:', e);
            }
        },
        
        /**
         * 初始化世界地图
         */
        initWorldMap: function() {
            const container = utils.$('#worldMap');
            if (!container || this.charts.worldMap) return;
            
            try {
                this.charts.worldMap = echarts.init(container);
                
                // 使用共享的国家数据，确保与柱状图数据一致
                const worldData = dataModel.getCountryData();
                
                const option = {
                    backgroundColor: 'transparent',
                    title: {
                        text: '全球访问热力图',
                        textStyle: { color: '#fff', fontSize: 16 }
                    },
                    tooltip: {
                        trigger: 'item',
                        formatter: function(params) {
                            // 只对核心国家（isCore=true）显示访问量，其他国家只显示名称
                            if (params.data && params.data.isCore) {
                                // 处理可能的NaN值，并格式化数据
                                const value = params.value && !isNaN(params.value) ? params.value : 0;
                                // 格式化为带千位分隔符的数字，与柱状图显示一致
                                const formattedValue = value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
                                return params.name + ': 访问量' + formattedValue;
                            } else {
                                // 非核心国家只显示名称
                                return params.name;
                            }
                        }
                    },
                    visualMap: {
                        min: 0,
                        max: 100000,
                        left: 'left',
                        top: 'bottom',
                        text: ['高', '低'],
                        textStyle: { color: '#fff' },
                        inRange: {
                            color: ['#313695', '#4575b4', '#74add1', '#abd9e9', '#e0f3f8', '#ffffbf', '#fee090', '#fdae61', '#f46d43', '#d73027', '#a50026']
                        }
                    },
                    toolbox: {
                        feature: {
                            saveAsImage: {},
                            restore: {}
                        }
                    },
                    series: [{
                        name: '访问量',
                        type: 'map',
                        map: 'world',
                        roam: true,
                        scaleLimit: {
                            min: 1,
                            max: 5
                        },
                        label: {
                            show: false
                        },
                        // 添加地图加载动画效果
                        animation: true,
                        animationDuration: 2500,
                        animationEasing: 'cubicOut',
                        animationDelay: function(idx) {
                            // 为不同国家设置不同的动画延迟，创造波浪效果
                            return idx * 20;
                        },
                        animationEasingUpdate: 'quinticInOut',
                        emphasis: {
                            label: {
                                show: true,
                                textStyle: {
                                    color: '#fff',
                                    fontSize: 14,
                                    fontWeight: 'bold'
                                },
                                // 添加标签出现动画
                                formatter: '{b}'
                            },
                            itemStyle: {
                                areaColor: '#718096',
                                // 添加悬停阴影和高亮效果
                                shadowBlur: 30,
                                shadowColor: 'rgba(113, 128, 150, 0.8)'
                            },
                            // 悬停动画配置
                            emphasisAnimation: true,
                            animationDuration: 400,
                            animationEasing: 'cubicOut'
                        },
                        data: worldData
                    }]
                };
                
                utils.safeSetOption(this.charts.worldMap, option, '世界地图初始化');
            } catch (e) {
                console.error('世界地图初始化失败:', e);
            }
        },
        
        /**
         * 初始化中国地图
         */
        initChinaMap: function() {
            const container = utils.$('#chinaMap');
            if (!container || this.charts.chinaMap) return;
            
            try {
                this.charts.chinaMap = echarts.init(container);
                
                // 使用共享的省份数据，确保与饼图数据一致
                const chinaData = dataModel.getProvinceData();
                
                const option = {
                    backgroundColor: 'transparent',
                    title: {
                        text: '国内访问热力图',
                        textStyle: { color: '#fff', fontSize: 16 }
                    },
                    tooltip: {
                        trigger: 'item',
                        formatter: function(params) {
                            // 处理可能的NaN值，并格式化数据
                            const value = params.value && !isNaN(params.value) ? params.value : 0;
                            // 格式化为带千位分隔符的数字，与柱状图显示一致
                            const formattedValue = value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
                            return params.name + ': 访问量' + formattedValue;
                        }
                    },
                    visualMap: {
                        min: 0,
                        max: 100000,
                        left: 'left',
                        top: 'bottom',
                        text: ['高', '低'],
                        textStyle: { color: '#fff' },
                        inRange: {
                            color: ['#e0f3f8', '#abd9e9', '#74add1', '#4575b4', '#313695', '#fee090', '#fdae61', '#f46d43', '#d73027', '#a50026']
                        }
                    },
                    toolbox: {
                        feature: {
                            saveAsImage: {},
                            restore: {}
                        }
                    },
                    series: [{
                        name: '访问量',
                        type: 'map',
                        map: 'china',
                        roam: true,
                        scaleLimit: {
                            min: 1,
                            max: 10
                        },
                        label: {
                            show: false
                        },
                        // 添加地图加载动画效果
                        animation: true,
                        animationDuration: 2000,
                        animationEasing: 'cubicOut',
                        animationDelay: function(idx) {
                            // 为不同省份设置不同的动画延迟，创造波浪效果
                            return idx * 30;
                        },
                        animationEasingUpdate: 'quinticInOut',
                        emphasis: {
                            label: {
                                show: true,
                                textStyle: {
                                    color: '#fff',
                                    fontSize: 14,
                                    fontWeight: 'bold'
                                },
                                // 添加标签出现动画
                                formatter: '{b}'
                            },
                            itemStyle: {
                                areaColor: '#ff7e67',
                                // 添加悬停阴影和高亮效果
                                shadowBlur: 30,
                                shadowColor: 'rgba(255, 126, 103, 0.8)'
                            },
                            // 悬停动画配置
                            emphasisAnimation: true,
                            animationDuration: 400,
                            animationEasing: 'cubicOut'
                        },
                        data: chinaData
                    }]
                };
                
                utils.safeSetOption(this.charts.chinaMap, option, '中国地图初始化');
            } catch (e) {
                console.error('中国地图初始化失败:', e);
            }
        },
        
        /**
         * 初始化国家访问量柱状图
         */
        initCountryChart: function() {
            const container = utils.$('#countryBarChart');
            if (!container || this.charts.countryChart) return;
            
            this.charts.countryChart = echarts.init(container);
            
            // 使用共享的国家数据，确保与地图数据一致
            const countryData = dataModel.getCountryData();
            
            // 映射英文国家名称到中文显示
            const nameMap = {
                'China': '中国',
                'United States': '美国',
                'Japan': '日本',
                'United Kingdom': '英国',
                'France': '法国',
                'Germany': '德国',
                'Canada': '加拿大',
                'Australia': '澳大利亚',
                'Russia': '俄罗斯',
                'India': '印度'
            };
            
            // 只使用核心国家数据（isCore=true）
            const coreCountryData = countryData.filter(item => item.isCore === true);
            
            // 准备柱状图数据，使用中文名称显示
            const countryNames = coreCountryData.map(item => nameMap[item.name] || item.name);
            const countryValues = coreCountryData.map(item => item.value);
            
            const option = {
                backgroundColor: 'transparent',
                tooltip: {
                    trigger: 'axis',
                    axisPointer: { type: 'shadow' }
                },
                toolbox: {
                    feature: {
                        dataZoom: {
                            yAxisIndex: 'none'
                        },
                        restore: {},
                        saveAsImage: {}
                    }
                },
                grid: {
                    left: '3%',
                    right: '10%',  // 为toolbox留出空间
                    bottom: '8%',
                    top: '3%',
                    containLabel: true
                },
                xAxis: {
                    type: 'category',
                    data: countryNames,
                    axisLine: { lineStyle: { color: '#fff' } },
                    axisLabel: {
                        interval: 0,
                        rotate: 30,
                        color: '#fff'
                    }
                },
                yAxis: {
                    type: 'value',
                    axisLine: { lineStyle: { color: '#fff' } },
                    axisLabel: { color: '#fff' },
                    splitLine: { lineStyle: { color: 'rgba(255, 255, 255, 0.1)' } }
                },
                series: [{
                    name: '访问量',
                    type: 'bar',
                    data: countryValues,
                    // 柱状图样式
                    itemStyle: {
                        // 新的渐变色
                        color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
                            { offset: 0, color: '#667eea' },
                            { offset: 0.5, color: '#764ba2' },
                            { offset: 1, color: '#667eea' }
                        ]),
                        // 圆角
                        borderRadius: [10, 10, 0, 0],
                        // 边框
                        borderColor: 'rgba(255, 255, 255, 0.3)',
                        borderWidth: 1
                    },
                    // 柱宽度
                    barWidth: '60%',
                    // 悬停效果
                    emphasis: {
                        itemStyle: {
                            color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
                                { offset: 0, color: '#f093fb' },
                                { offset: 0.5, color: '#f5576c' },
                                { offset: 1, color: '#f093fb' }
                            ]),
                            // 悬停时添加阴影
                            shadowBlur: 20,
                            shadowColor: 'rgba(240, 147, 251, 0.5)'
                        },
                        // 悬停时缩放
                        scale: true,
                        scaleSize: 5
                    },
                    // 数据加载动画
                    animationDuration: 1500,
                    animationEasing: 'elasticOut',
                    animationDelay: function (idx) {
                        // 每个柱子延迟不同时间，产生阶梯效果
                        return idx * 100;
                    },
                    // 点击交互
                    select: {
                        itemStyle: {
                            color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
                                { offset: 0, color: '#4facfe' },
                                { offset: 0.5, color: '#00f2fe' },
                                { offset: 1, color: '#4facfe' }
                            ]),
                            borderColor: '#fff',
                            borderWidth: 2
                        }
                    }
                }]
            };
            
            utils.safeSetOption(this.charts.countryChart, option, '国家访问量柱状图初始化');
        },
        
        /**
         * 初始化省份分布饼图
         */
        initProvinceChart: function() {
            const container = utils.$('#provincePieChart');
            if (!container || this.charts.provinceChart) return;
            
            this.charts.provinceChart = echarts.init(container);
            
            // 使用共享的省份数据，确保与地图数据一致
            const provinceData = dataModel.getProvinceData();
            
            // 省份全称到简称的映射，确保饼图显示简称
            const provinceShortNameMap = {
                '广东省': '广东',
                '北京市': '北京',
                '上海市': '上海',
                '江苏省': '江苏',
                '浙江省': '浙江',
                '山东省': '山东',
                '四川省': '四川',
                '湖北省': '湖北',
                '河南省': '河南',
                '福建省': '福建'
            };
            
            // 只使用核心省份数据（isCore=true），确保非核心省份不加入统计图表
            const coreProvinceData = provinceData.filter(item => item.isCore === true);
            
            // 转换数据，使用简称显示
            const displayData = coreProvinceData.map(item => ({
                name: provinceShortNameMap[item.name] || item.name,
                value: item.value
            }));
            
            const option = {
                backgroundColor: 'transparent',
                tooltip: { trigger: 'item' },
                toolbox: {
                    feature: {
                        restore: {},
                        saveAsImage: {}
                    }
                },
                legend: {
                    orient: 'vertical',
                    left: 'left',
                    textStyle: { color: '#fff' }
                },
                series: [{
                    name: '访问量',
                    type: 'pie',
                    radius: '50%',
                    center: ['60%', '50%'],
                    data: displayData,
                    emphasis: {
                        itemStyle: {
                            shadowBlur: 10,
                            shadowOffsetX: 0,
                            shadowColor: 'rgba(0, 0, 0, 0.5)'
                        }
                    }
                }]
            };
            
            utils.safeSetOption(this.charts.provinceChart, option, '省份分布饼图初始化');
        },
        
        /**
         * 初始化年龄分布图表
         */
        initAgeChart: function() {
            const container = utils.$('#ageChart');
            if (!container || this.charts.ageChart) return;
            
            this.charts.ageChart = echarts.init(container);
            const ageValues = dataModel.ageGroups.map(() => utils.random(10000, 100000));
            
            const option = {
                backgroundColor: 'transparent',
                tooltip: { trigger: 'axis' },
                toolbox: {
                    feature: {
                        dataZoom: {},
                        restore: {},
                        saveAsImage: {}
                    }
                },
                grid: {
                    left: '3%',
                    right: '10%',  // 为toolbox留出空间
                    bottom: '3%',
                    containLabel: true
                },
                xAxis: {
                    type: 'category',
                    data: dataModel.ageGroups,
                    axisLine: { lineStyle: { color: '#fff' } },
                    axisLabel: { color: '#fff' }
                },
                yAxis: {
                    type: 'value',
                    axisLine: { lineStyle: { color: '#fff' } },
                    axisLabel: { color: '#fff' },
                    splitLine: { lineStyle: { color: 'rgba(255, 255, 255, 0.1)' } }
                },
                series: [{
                    name: '访问量',
                    type: 'line',
                    stack: '总量',
                    data: ageValues,
                    lineStyle: { color: '#5470c6' },
                    areaStyle: {
                        color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
                            { offset: 0, color: 'rgba(84, 112, 198, 0.5)' },
                            { offset: 1, color: 'rgba(84, 112, 198, 0.1)' }
                        ])
                    }
                }]
            };
            
            utils.safeSetOption(this.charts.ageChart, option, '年龄分布图表初始化');
        },
        
        /**
         * 初始化趋势折线图
         */
        initTrendChart: function() {
            const container = utils.$('#trendLine');
            if (!container || this.charts.trendChart) return;
            
            this.charts.trendChart = echarts.init(container);
            const dates = utils.generateDateArray(30);
            const values = dates.map(() => utils.random(50000, 200000));
            
            const option = {
                backgroundColor: 'transparent',
                tooltip: { trigger: 'axis' },
                toolbox: {
                    feature: {
                        dataZoom: {},
                        restore: {},
                        saveAsImage: {}
                    }
                },
                grid: {
                    left: '3%',
                    right: '10%',  // 为toolbox留出空间
                    bottom: '3%',
                    containLabel: true
                },
                xAxis: {
                    type: 'category',
                    boundaryGap: false,
                    data: dates,
                    axisLine: { lineStyle: { color: '#fff' } },
                    axisLabel: { color: '#fff' }
                },
                yAxis: {
                    type: 'value',
                    axisLine: { lineStyle: { color: '#fff' } },
                    axisLabel: { color: '#fff' },
                    splitLine: { lineStyle: { color: 'rgba(255, 255, 255, 0.1)' } }
                },
                series: [{
                    name: '访问量',
                    type: 'line',
                    stack: '总量',
                    data: values,
                    lineStyle: { color: '#91cc75' },
                    areaStyle: {
                        color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
                            { offset: 0, color: 'rgba(145, 204, 117, 0.5)' },
                            { offset: 1, color: 'rgba(145, 204, 117, 0.1)' }
                        ])
                    }
                }]
            };
            
            utils.safeSetOption(this.charts.trendChart, option, '趋势折线图初始化');
        },
        
        /**
         * 设置事件监听器
         */
        setupEventListeners: function() {
            // 窗口大小改变时重新调整图表大小
            window.addEventListener('resize', () => this.handleResize());
        },
        
        /**
         * 处理窗口大小改变
         */
        handleResize: function() {
            Object.values(this.charts).forEach(chart => {
                if (chart && !chart.isDisposed()) {
                    chart.resize();
                }
            });
        },
        
        /**
         * 清理资源
         */
        destroy: function() {
            // 清理定时器
            Object.values(this.timers).forEach(timerId => utils.clearTimer(timerId));
            
            // 销毁图表实例
            Object.values(this.charts).forEach(chart => {
                if (chart && !chart.isDisposed()) {
                    chart.dispose();
                }
            });
        }
    };
    
    /* ========== 动画和效果控制器 ========== */
    const EffectsController = {
        /**
         * 启动所有效果
         */
        startAllEffects: function() {
            // 地图相关效果已移除
            console.log('所有图表效果已启动');
        },
        
        /**
         * 停止所有效果
         */
        stopAllEffects: function() {
            // 清理定时器
            for (const timerKey in ChartController.timers) {
                ChartController.timers[timerKey] = utils.clearTimer(ChartController.timers[timerKey]);
            }
        }
    };
    
    /* ========== 指标控制器 ========== */
    // MetricsController已移除，不再需要动态更新指标
    
    /* ========== 公共接口 ========== */
    return {
        /**
         * 初始化仪表盘
         */
        init: function() {
            try {
                // 检查地图数据是否已加载
                if (typeof echarts !== 'undefined') {
                    // 先检查是否已经有注册的地图数据
                    const hasChinaMap = echarts.getMap('china');
                    const hasWorldMap = echarts.getMap('world');
                    
                    console.log('地图数据状态 - 中国地图:', !!hasChinaMap);
                    console.log('地图数据状态 - 世界地图:', !!hasWorldMap);
                    
                    // 初始化图表
                    ChartController.init();
                    
                    // 启动效果
                    EffectsController.startAllEffects();
                    
                    // 初始化热点词云
                    if (typeof hotspotData !== 'undefined' && typeof renderWordCloud !== 'undefined') {
                        console.log('初始化热点词云');
                        // 使用最近1小时的数据初始化词云
                        renderWordCloud(hotspotData['1h']);
                        // 设置定时刷新词云，每30秒刷新一次
                        setInterval(() => {
                            if (typeof refreshHotspot === 'function') {
                                refreshHotspot();
                            }
                        }, 30000);
                    }
                    
                    console.log('仪表盘初始化成功');
                } else {
                    console.error('ECharts 未加载');
                }
            } catch (error) {
                console.error('仪表盘初始化失败:', error);
            }
        },
        
        /**
         * 销毁仪表盘
         */
        destroy: function() {
            EffectsController.stopAllEffects();
            ChartController.destroy();
            console.log('仪表盘已销毁');
        },
        
        
        /**
         * 暴露工具函数
         */
        utils: utils
    };
})();

/* ========== 页面加载完成后初始化 ========== */
document.addEventListener('DOMContentLoaded', () => {
    Dashboard.init();
});

// 计数器动画已移除，不再需要initCounters函数

// 填充带货榜数据
function fillSalesRanking() {
    const salesData = [
        { rank: 1, anchor: '李佳琦', sales: 21560000, percentage: 23.8 },
        { rank: 2, anchor: '东方甄选', sales: 17890000, percentage: 19.8 },
        { rank: 3, anchor: '交个朋友', sales: 13560000, percentage: 15.0 },
        { rank: 4, anchor: '罗永浩', sales: 11230000, percentage: 12.4 },
        { rank: 5, anchor: '辛巴', sales: 9870000, percentage: 10.9 }
    ];
    
    const tbody = document.getElementById('salesTop5');
    if (tbody) {
        tbody.innerHTML = '';
        salesData.forEach(item => {
            const row = document.createElement('tr');
            row.innerHTML = `
                <td>${item.rank}</td>
                <td>${item.anchor}</td>
                <td>¥${(item.sales / 10000).toFixed(2)}万</td>
                <td>${item.percentage}%</td>
            `;
            tbody.appendChild(row);
        });
    }
}

// 生成最新成交数据
function pushOrder() {
    const goods = ['iPhone 15 Pro', '华为 Mate 60 Pro', '索尼 PS5', '戴森吹风机', 'SK-II神仙水', '五粮液', '苹果 Watch Ultra', 'MacBook Air M3', 'iPad Air', 'switch OLED', '小米14 Pro', 'AirPods Pro 2'];
    const cities = ['北京', '上海', '广州', '深圳', '杭州', '成都', '南京', '武汉', '西安', '重庆', '苏州', '天津'];
    const box = document.getElementById('orderStream');
    if (!box) return;
    
    const item = document.createElement('div');
    item.className = 'data-stream-item';
    item.style.opacity = '0';
    item.style.transition = 'opacity 0.3s ease-in';
    
    // 随机生成金额（增加价格范围以反映11月购物季特点）
    const amount = Math.floor(Math.random() * 19900) + 100;
    
    item.innerHTML = `🎉 <strong>${cities[Math.floor(Math.random() * cities.length)]}</strong> 用户刚刚购买了 <strong>${goods[Math.floor(Math.random() * goods.length)]}</strong> ¥${amount.toLocaleString()}`;
    box.insertBefore(item, box.firstChild);
    
    // 添加出现动画
    setTimeout(() => {
        item.style.opacity = '1';
    }, 10);
    
    if (box.children.length > 8) {
        const lastItem = box.lastChild;
        lastItem.style.opacity = '0';
        setTimeout(() => {
            if (box.contains(lastItem)) {
                box.removeChild(lastItem);
            }
        }, 500);
    }
}

// 使用延迟确保Dashboard对象已加载完成
setTimeout(() => {
    // 填充带货榜数据
    fillSalesRanking();
    // 初始填充一些订单数据
    for (let i = 0; i < 5; i++) {
        pushOrder();
    }
    // 设置每2秒推送一条新订单
    setInterval(pushOrder, 2000);
}, 100);

// 页面卸载时清理资源
window.addEventListener('beforeunload', () => {
    Dashboard.destroy();
});